home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Environments / PowerMacOberon feb96 / Debugger / RTDD.Mod (.txt) < prev    next >
Encoding:
Oberon Text  |  1995-12-14  |  14.8 KB  |  409 lines  |  [TEXT/.Ob4]
  1. Syntax10.Scn.Fnt
  2. StampElems
  3. Alloc
  4. 14 Dec 95
  5. InfoElems
  6. Alloc
  7. Syntax10.Scn.Fnt
  8. StampElems
  9. Alloc
  10. 14 Dec 95
  11. "Title": Run time debugger
  12. "Author": mah
  13. "Abstract": data texts module
  14. "Keywords": 
  15. "Version": 
  16. "From":  31.1.95 11:49:38
  17. "Until": 
  18. "Changes": 
  19. 20.03.95    : statt = jetzt : bei arrays
  20. 28.03.95    FoldElems be records & arrays komprimierter
  21. ParcElems
  22. Alloc
  23. Syntax10i.Scn.Fnt
  24. FoldElems
  25. Syntax10.Scn.Fnt
  26.         indent : INTEGER;
  27.         obj: RTDC.Sym;
  28.         adr: LONGINT;
  29.     END;
  30. Syntax10.Scn.Fnt
  31.         indent: INTEGER;
  32.         writer: Texts.Writer;
  33.         text: Texts.Text;
  34.         baseAdr: LONGINT;
  35.         reg: Sys.ExceptionInfo
  36.     END;
  37. Syntax10b.Scn.Fnt
  38. Syntax10.Scn.Fnt
  39. VAR e: FoldElem;
  40. BEGIN
  41.     NEW (e); e.mode := mode; e.W := FoldElems.elemW; e.H := FoldElems.elemH; e.handle := FoldElemHandler;
  42.     e.obj:=obj; e.adr:=adr; e.indent:=indent; e.visible:=TRUE;
  43.     IF (mode = FoldElems.expLeft) OR (mode = FoldElems.colLeft) THEN NEW (e.hidden); Texts.OpenBuf (e.hidden) END;
  44.     RETURN e
  45. END AllocFoldElem;
  46. Syntax10.Scn.Fnt
  47. VAR i : INTEGER;
  48. BEGIN FOR i := 1 TO in DO Texts.Write (w, 09X) END
  49. END WriteIndent;
  50. Syntax10.Scn.Fnt
  51. Syntax10i.Scn.Fnt
  52.     c: CHAR;
  53.     l: LONGINT;
  54.     i: INTEGER;
  55.     r: REAL;
  56.     lr: LONGREAL;
  57.     s: SET;
  58.     si: SHORTINT;
  59.     name: ARRAY 64 OF CHAR;
  60.     first: BOOLEAN;
  61. BEGIN
  62.     CASE o.typ.form OF
  63.           Byte:
  64.                 IF reg THEN SYS.GET (adr, l); c := CHR(SHORT(SHORT(l))) ELSE SYS.GET (adr, c) END;
  65.                 Texts.WriteInt (w, ORD(c), 0)
  66.         | Bool:
  67.                 IF reg THEN
  68.                     IF adr # 0 THEN c := CHR (1) ELSE c := CHR (0) END
  69.                 ELSE
  70.                     SYS.GET (adr, c)
  71.                 END;
  72.                 IF ORD (c) # 0 THEN Texts.WriteString(w, "TRUE") ELSE Texts.WriteString(w, "FALSE") END
  73.         | Char:
  74.                 IF reg THEN SYS.GET (adr, l); c := CHR (SHORT (SHORT (l))) ELSE SYS.GET (adr, c) END;
  75.                 IF (c < ' ') OR (c > '~') THEN
  76.                     Texts.WriteString (w, "CHR (");
  77.                     Texts.WriteInt (w, ORD(c), 0);
  78.                     Texts.Write (w, ')')
  79.                 ELSE 
  80.                     Texts.Write (w, 27X); Texts.Write (w, c); Texts.Write (w, 27X)
  81.                 END
  82.         | SInt:
  83.                 IF reg THEN SYS.GET (adr, l); si := SHORT (SHORT (l)) ELSE SYS.GET (adr, si) END;
  84.                 Texts.WriteInt (w, si, 0)
  85.         | Int: 
  86.                 IF reg THEN SYS.GET (adr, l) ELSE SYS.GET (adr, i); l := i END;
  87.                 Texts.WriteInt (w, l, 0)
  88.         | LInt:
  89.                 SYS.GET (adr, l);
  90.                 Texts.WriteInt (w, l, 0) 
  91.         | Real: 
  92.                 IF reg THEN SYS.GET (adr, lr); r := SHORT (lr) ELSE SYS.GET (adr, r) END;
  93.                 Texts.WriteLongReal (w, r, 15)
  94.         | LReal: 
  95.                 SYS.GET (adr, lr);
  96.                 Texts.WriteLongReal (w, lr, 20)
  97.         | Set: 
  98.                 SYS.GET (adr, s);
  99.                 first := TRUE;
  100.                 Texts.Write (w, '{');
  101.                 FOR i := 0 TO 31 DO
  102.                     IF i IN s THEN
  103.                         IF ~first THEN Texts.WriteString (w, ", ") END;
  104.                         Texts.WriteInt (w, i, 0);
  105.                         first := FALSE
  106.                     END
  107.                 END;
  108.                 Texts.Write (w, '}')
  109.         |Pointer: Texts.WriteString (w, "NIL")            (* only nil pointers handled here *) 
  110.         |ProcTyp:
  111.                 SYS.GET (adr, l);
  112.                 RTDT.FindProc (l, name);
  113.                 IF name = "" THEN
  114.                     Texts.WriteHex (w, l); Texts.Write (w, 'H')
  115.                 ELSE
  116.                     Texts.WriteString (w, name)
  117.                 END
  118.         |Comp: (* array of char *)
  119.                 RTDT.ConvertAdr (adr);
  120.                 IF o.typ.comp = DynArr THEN SYS.GET (adr, o.typ.n); INC (adr, 4)
  121.                 ELSIF o.typ.comp = -Array THEN o.typ.comp := DynArr
  122.                 END;
  123.                 SYS.GET (adr, c);
  124.                 Texts.Write (w, '"');
  125.                 i := 1;
  126.                 WHILE c#CHR(0) DO Texts.Write (w, c); SYS.GET (adr+i, c); INC (i) END;
  127.                 Texts.Write (w, '"')
  128.         ELSE
  129.             Texts.WriteString (w, "Unknown type")
  130. END ShowValue;
  131. Syntax10.Scn.Fnt
  132. BEGIN adr := baseAdr + o.adr
  133. END CalcGlobalAdr;
  134. Syntax10.Scn.Fnt
  135. VAR nxt, l: LONGINT;
  136. BEGIN
  137.     IF o.linkadr < 0 THEN
  138.         reg := TRUE;
  139.           adr := -1 - o.linkadr; 
  140.         adr := adr MOD 32;
  141.         IF (o.typ.comp = Record) & (o.mode = 2) THEN
  142.             SYS.GET (regs.reg.R[2 * adr + 3] - 4, l); o.adr := l - 2
  143.         ELSIF (o.typ.comp = DynArr) & (o.mode # 2) THEN
  144.             SYS.GET (regs.reg.R[2 * adr + 3] - 4, l); o.adr := l - 2
  145.         ELSE
  146.             o.adr := 0
  147.         END;
  148.         IF adr < 31 THEN nxt := regs.reg.R[2 * adr + 3] END;
  149.         IF o.typ.form = ProcTyp THEN adr := SYS.ADR (regs.reg.R[2 * adr + 1])
  150.         ELSIF o.typ.form = Bool THEN
  151.             IF adr IN SYS.VAL(SET, regs.spec.CR) THEN adr := 1 ELSE adr := 0 END
  152.         ELSE
  153.             IF (o.typ.form = LReal) OR (o.typ.form = Real) THEN
  154.                 adr := SYS.ADR (regs.fp.R[2 * adr])
  155.             ELSE 
  156.                 adr := SYS.ADR (regs.reg.R[2 * adr + 1])
  157.             END
  158.         END
  159.     ELSE
  160.         reg := FALSE;
  161.         adr := o.linkadr + regs.reg.R[2 * 31 + 1]
  162.     END;
  163.     IF (o.mode = 2) OR ((o.typ.form = Comp) & (o.typ.comp = DynArr)) THEN SYS.GET (adr, adr); reg := FALSE END;
  164.     IF (o.typ.form = Comp) & (o.typ.comp = DynArr) THEN
  165.         o.typ.n := nxt;
  166.         o.typ.comp := -Array
  167. END CalcLocalAdr;
  168. Syntax10.Scn.Fnt
  169. Syntax10i.Scn.Fnt
  170. VAR l : LONGINT;
  171. BEGIN
  172.     IF (o.typ.form = Comp) & (ABS (o.typ.comp) = Array) &
  173.         (o.typ.BaseTyp.strobj # NIL) &
  174.         (o.typ.BaseTyp.strobj.name = "CHAR") THEN            (* array of char as string *)
  175.             RETURN FALSE
  176.     END;
  177.     IF o.typ.form = Comp THEN RETURN TRUE END;        (* arrays & records *)
  178.     IF o.typ.form # Pointer THEN RETURN FALSE END;
  179.     SYS.GET (adr, l);
  180.     IF l = 0 THEN RETURN FALSE END;                        (* pointer to NIL *)
  181.     RETURN TRUE
  182. END IsComplex;
  183. Syntax10.Scn.Fnt
  184. VAR r: Texts.Reader; f: FoldElem;
  185. l1, l2: LONGINT;
  186. BEGIN
  187.     IF t # NIL THEN
  188.         Texts.OpenReader (r, t, 0); Texts.ReadElem (r);
  189.         WHILE ~r.eot DO
  190.             IF r.elem IS FoldElem THEN
  191.                 f := r.elem(FoldElem);
  192. IF f.mode = FoldElems.expLeft THEN
  193.     l1 := adr; l2 := f.adr;
  194.     IF type.form = 13 THEN
  195.         SYS.GET (adr, l1); SYS.GET (f.adr, l2);
  196.     END;
  197. (*                IF (f.adr = adr) & (f.obj.typ = type) THEN RETURN f.mode = FoldElems.expLeft END  *)
  198.                 IF (l1 = l2) & (f.obj.typ = type) & (f.indent = indent) THEN RETURN f.mode = FoldElems.expLeft END 
  199.         END;
  200.             Texts.ReadElem (r)
  201.         END
  202.     END;
  203.     RETURN FALSE    
  204. END Opened;
  205. Syntax10.Scn.Fnt
  206. Syntax10i.Scn.Fnt
  207. VAR o: RTDC.Sym; t: Types.Type;
  208. BEGIN
  209.     IF (obj.mode = 2) & (obj.adr # 0) THEN  (* record as var par or record by pointer *)
  210.         t := SYS.VAL (Types.Type, obj.adr)
  211.     END;
  212. IF SYS.VAL (LONGINT, t) = -1 THEN RETURN END;
  213.     IF (t # NIL) & (t.name[0] # CHR(0)) THEN o := RTDC.FindType (t, t.module) END;
  214. (*    IF o # NIL THEN obj.typ := o.typ END *)
  215. END GetType;
  216. Syntax10.Scn.Fnt
  217.     dim, i, j: LONGINT;
  218.     sn, s, sb: RTDC.Type;
  219.     n: ARRAY 20 OF LONGINT; 
  220. BEGIN
  221.     dim := o.typ.n; 
  222.     s := o.typ;
  223.     FOR i := 0 TO dim DO
  224.         NEW (sn); sn^ := s^; sn.comp := 2;
  225.         IF i = 0 THEN o.typ := sn ELSE sb.BaseTyp := sn END;
  226.         sb := sn;
  227.         SYS.GET (adr + 4 * i + 12, sn.n);
  228.         n[i] := sn.n;
  229.         s := s.BaseTyp
  230.     END;
  231.     sn := o.typ; i := dim;
  232.     REPEAT
  233.         s := o.typ;
  234.         j := 0; WHILE j # i DO INC (j); s := s.BaseTyp END;
  235.         s.size := n[i] * s.BaseTyp.size;
  236.         DEC (i)
  237.     UNTIL i = -1;
  238.     adr := adr + 12 + 4 * (dim + 1);
  239.     INC (adr, (-adr) MOD 8)
  240. END ConvertDynamic;
  241. Syntax10.Scn.Fnt
  242. Syntax10i.Scn.Fnt
  243.     obj: RTDC.Sym;
  244.     i, a: LONGINT;
  245. BEGIN
  246.     IF o.typ.form = Pointer THEN
  247.         SYS.GET (adr, adr);
  248.         SYS.GET (adr - 4, a);
  249.         SYS.GET (a - 4, a);                (* fetch super tag *)
  250.         NEW (obj); obj^ := o^; o := obj;
  251.         o.adr := a - 2;                    (* remove mark bit *)
  252.         o.mode := 2;                        (* mark for possible different runtimetype *)
  253.         o.typ:=o.typ.BaseTyp
  254.     END;
  255.     IF o.typ.comp = DynArr THEN
  256.         ConvertDynamic (o, adr);    
  257.     END;
  258.     NEW (obj);
  259.     obj.typ:=o.typ.BaseTyp;
  260.     IF ABS (o.typ.comp) = Array THEN
  261.         IF IsComplex (o, adr) THEN
  262.             FOR i := 0 TO o.typ.n-1 DO
  263.                 Texts.WriteLn (w);
  264.                 WriteIndent (w, indent);
  265.                 IF IsComplex (obj, adr + i * obj.typ.size) THEN
  266.                     IF obj.typ.comp = Record THEN Texts.WriteString (w, "RECORD ")
  267.                     ELSIF obj.typ.comp = Array THEN Texts.WriteString (w, "ARRAY ")
  268.                     ELSE Texts.WriteString (w, "POINTER ")
  269.                     END;
  270.                     Texts.WriteInt (w, i, 0); Texts.Write (w, ' ');
  271.                     IF Opened (t, adr+i*obj.typ.size, obj.typ, indent) THEN
  272.                         Texts.WriteElem (w, AllocFoldElem (obj, adr+i*obj.typ.size, indent + 1, FoldElems.expLeft));
  273.                         ShowExpansion (w, obj, adr+i*obj.typ.size, indent + 1, t);
  274.                         Texts.WriteElem (w, AllocFoldElem (obj, adr+i*obj.typ.size, indent + 1, FoldElems.expRight))
  275.                     ELSE
  276.                         Texts.WriteElem (w, AllocFoldElem (obj, adr+i*obj.typ.size, indent + 1, FoldElems.colLeft));
  277.                         Texts.WriteElem (w, AllocFoldElem (obj, adr+i*obj.typ.size, indent + 1, FoldElems.colRight))
  278.                     END
  279.                 ELSE
  280.                     Texts.WriteInt (w, i, 0); Texts.WriteString (w, ": ");
  281.                     ShowValue (w, obj, adr + i * o.typ.BaseTyp.size, FALSE)
  282.                 END
  283.             END
  284.         ELSE                            (* ARRAY OF CHAR *)
  285.             Texts.Write (w, ' ');
  286.             ShowValue (w, o, adr, FALSE)
  287.         END;
  288.         Texts.Write (w, ' ')
  289.     ELSE            (* record *)
  290.         IF o.mode = 2 THEN GetType (o, adr) END;         (* determine runtime type *)
  291.         IF o.typ.BaseTyp#NIL THEN
  292.             obj.typ := o.typ.BaseTyp;
  293.             Texts.Write (w, ' ');
  294.             IF Opened (t, adr, obj.typ, indent) THEN
  295.                 Texts.WriteElem (w, AllocFoldElem (obj, adr, indent, FoldElems.expLeft));
  296.                 ShowExpansion (w, obj, adr, indent, t);
  297.                 Texts.WriteElem (w, AllocFoldElem (obj, adr, indent, FoldElems.expRight))
  298.             ELSE
  299.                 Texts.WriteElem (w, AllocFoldElem (obj, adr, indent, FoldElems.colLeft));
  300.                 Texts.WriteElem (w, AllocFoldElem (obj, adr, indent, FoldElems.colRight))
  301.             END
  302.         END;
  303.         Texts.WriteLn (w);
  304.         GetScope (w, t, o.typ.link, adr, indent);
  305.         Texts.Write (w, ' ')
  306. END ShowExpansion;
  307. Syntax10.Scn.Fnt
  308. VAR w: Texts.Writer; new: FoldElem;
  309. BEGIN
  310.     WITH e: FoldElem DO
  311.         IF (m IS FoldElems.PrepSwitchMsg) & (e.mode = FoldElems.colLeft) THEN
  312.             Texts.OpenWriter (w);
  313.             ShowExpansion (w, e.obj, e.adr, e.indent, Texts.ElemBase (e));
  314.             e.hidden := w.buf
  315.         ELSIF m IS Texts.CopyMsg THEN
  316.             NEW (new); Texts.CopyElem (e, new);
  317.             new.mode := e.mode; new.visible := e.visible;
  318.             IF e.mode IN {FoldElems.colLeft, FoldElems.expLeft, FoldElems.tempLeft, FoldElems.findLeft} THEN
  319.                 NEW(new.hidden); Texts.OpenBuf(new.hidden); Texts.Copy(e.hidden, new.hidden)
  320.             END;
  321.             m(Texts.CopyMsg).e := new
  322.         ELSE
  323.             FoldElems.FoldHandler (e, m)
  324.         END
  325. END FoldElemHandler;
  326. Syntax10.Scn.Fnt
  327. VAR v, old: View;
  328. BEGIN
  329.     NEW (v); v.indent := indent; v.baseAdr := baseAdr; v.text := t; v.writer := w;
  330.     old := curView; curView := v;
  331.     inhibit := TRUE; RTDC.ScanScope (syms, CollectProc);
  332.     w := v.writer; curView := old
  333. END GetScope;
  334. Syntax10.Scn.Fnt
  335. VAR v, old: View;
  336. BEGIN
  337.     NEW (v); v.indent := indent; v.reg := reg; v.text := t; v.writer := w;
  338.     old := curView; curView := v;
  339.     inhibit := TRUE; RTDC.ScanScope (syms, CollectProc);
  340.     w := v.writer; curView := old
  341. END GetLocalScope;
  342. MODULE RTDD; (* Run time debugger: Data texts; mah 31.1.95 (
  343. IMPORT RTDT, RTDC, Texts, TextFrames, SYS := SYSTEM, FoldElems, Modules, Types, Sys;
  344. CONST
  345.     (* structure forms *)
  346.     Undef = 0; Byte = 1; Bool = 2; Char = 3; SInt = 4; Int = 5; LInt = 6;
  347.     Real = 7; LReal = 8; Set = 9; String = 10; NilTyp = 11; NoTyp = 12;
  348.     Pointer = 13; ProcTyp = 14; Comp = 15;
  349.     (* composite structure forms *)
  350.     Basic = 1; Array = 2; DynArr = 3; Record = 4;
  351.     FoldElem = POINTER TO FoldElemDesc;
  352.     FoldElemDesc = RECORD (FoldElems.ElemDesc)
  353.     View = POINTER TO ViewDesc;
  354.     ViewDesc = RECORD
  355.     curView: View;
  356.     inhibit: BOOLEAN;
  357. PROCEDURE ^FoldElemHandler (e: Texts.Elem; VAR m: Texts.ElemMsg);
  358. PROCEDURE ^GetScope* (VAR w: Texts.Writer; t: Texts.Text; syms: RTDC.Sym; baseAdr: LONGINT; indent: INTEGER);
  359. PROCEDURE AllocFoldElem (obj: RTDC.Sym; adr: LONGINT; indent: INTEGER; mode: SHORTINT) : FoldElem;
  360. PROCEDURE WriteIndent (VAR w: Texts.Writer; in : INTEGER);
  361.  Write 'in' tabs 
  362. PROCEDURE ShowValue (VAR w: Texts.Writer; o : RTDC.Sym; adr : LONGINT; reg : BOOLEAN);
  363. PROCEDURE CalcGlobalAdr (baseAdr: LONGINT; o: RTDC.Sym; VAR adr: LONGINT);
  364. PROCEDURE CalcLocalAdr (regs: Sys.ExceptionInfo; o: RTDC.Sym; VAR adr: LONGINT; VAR reg: BOOLEAN);
  365. PROCEDURE IsComplex (o : RTDC.Sym; adr : LONGINT) : BOOLEAN;
  366. PROCEDURE Opened (t: Texts.Text; adr: LONGINT; type: RTDC.Type; indent: INTEGER) : BOOLEAN;
  367. PROCEDURE GetType (VAR obj: RTDC.Sym; adr: LONGINT);
  368.  converts obj.typ to actual runtime type 
  369. PROCEDURE ConvertDynamic (VAR o: RTDC.Sym; VAR adr: LONGINT);
  370.  converts DynArray to Array 
  371. PROCEDURE ShowExpansion (VAR w: Texts.Writer; o: RTDC.Sym; adr: LONGINT; indent: INTEGER; t: Texts.Text);
  372. PROCEDURE FoldElemHandler (e: Texts.Elem; VAR m: Texts.ElemMsg);
  373. PROCEDURE CollectProc (obj: RTDC.Sym);
  374. VAR reg: BOOLEAN; adr, l: LONGINT; e: FoldElem; 
  375. BEGIN
  376.     IF (obj.mode # 1) & (obj.mode # 2) & (obj.mode # 4) THEN RETURN END; (* VAR, VARPAR, FIELD *)
  377.     IF obj.name[0] = '@' THEN RETURN END;
  378.     IF curView.reg = NIL THEN 
  379.         CalcGlobalAdr (curView.baseAdr, obj, adr); reg := FALSE
  380.     ELSE
  381.         CalcLocalAdr (curView.reg, obj, adr, reg)
  382.     END;
  383.     IF inhibit THEN inhibit := FALSE ELSE Texts.WriteLn (curView.writer) END;
  384.     RTDT.ConvertAdr (adr);
  385.     WriteIndent (curView.writer, curView.indent); Texts.WriteString (curView.writer, obj.name);
  386.     IF obj.typ.form = 13 THEN Texts.Write (curView.writer, '^') END;
  387.     Texts.Write (curView.writer, ' ');
  388.     IF IsComplex (obj, adr) THEN
  389.         IF Opened (curView.text, adr, obj.typ, curView.indent + 1) THEN
  390.             e := AllocFoldElem (obj, adr, curView.indent + 1, FoldElems.expLeft); 
  391.             Texts.WriteElem (curView.writer, e);
  392.             ShowExpansion (curView.writer, obj, adr, curView.indent + 1, curView.text);
  393.             e := AllocFoldElem (obj, adr, curView.indent + 1, FoldElems.expRight);
  394.             Texts.WriteElem (curView.writer, e)
  395.         ELSE
  396.             e := AllocFoldElem (obj, adr, curView.indent + 1, FoldElems.colLeft); 
  397.             Texts.WriteElem (curView.writer, e);
  398. (*            IF obj.typ.form = 13 THEN SYS.GET (adr, l); Texts.WriteHex (curView.writer, l); Texts.WriteString (curView.writer, "H ") END; *)
  399.             e := AllocFoldElem (obj, adr, curView.indent + 1, FoldElems.colRight);
  400.             Texts.WriteElem (curView.writer, e)
  401.         END
  402.     ELSE
  403.         Texts.WriteString (curView.writer, "= ");
  404.         ShowValue (curView.writer, obj, adr, reg)
  405. END CollectProc;
  406. PROCEDURE GetScope* (VAR w: Texts.Writer; t: Texts.Text; syms: RTDC.Sym; baseAdr: LONGINT; indent: INTEGER);
  407. PROCEDURE GetLocalScope* (VAR w: Texts.Writer; t: Texts.Text; syms: RTDC.Sym; reg: Sys.ExceptionInfo; indent: INTEGER);
  408. END RTDD.
  409.